home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / server.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  22KB  |  753 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE    
  2.    No guarantees or restrictions.  See the readme file for the full standard 
  3.    disclaimer.
  4.    5.29.90    Harry Morris, morris@think.com
  5. */
  6.  
  7. /* this file is a server process for a unix machine that takes input from 
  8.    standard in or from a socket and searches the local search engine on the 
  9.    unix box.
  10.    originally written by harry morris.
  11.    modified by brewster kahle. 7/90
  12.    6.xx.90    Brewster - initial implementation of stdio interface
  13.    7.xx.90    Patrick Bray - support for headers and forking processes
  14.    90.07.31    Ephraim - support for logging 
  15.  
  16.    91.03.03     Jonathan - set searchLog to log_out.
  17.    91.05.23    Jonathan - added fork process for indexer.
  18.                            Fixed version display so it exits.
  19.    91.05.25     Jonathan - added setuid.
  20.    
  21.    Tue Jul  9 12:11:02 1991 -- Michael Haberler mah@wu-wien.ac.at
  22.  
  23.                 Added semi-intelligent INFO database indexing (only done if
  24.         any of the .src files is newer than INFO.dct)
  25.         
  26.         Locking against multiple concurrent INFO rebuilds if 
  27.         running under inetd
  28.  
  29.         Use scandir() for directory operations
  30.  
  31.         Works under inetd as well as standalone. Here are my inetd.conf
  32.            entries (not the missing userid in the Ultrix inetd.conf!):
  33.  
  34.    hpux 7.0/800, Interactive/386 2.2.1:
  35.     z3950 stream tcp nowait root /usr/local/etc/waisserver waisserver -s \
  36.         -d /usr/logins/mah/wais-sources
  37.  
  38.    Ultrix 4.1:
  39.     z3950 stream tcp nowait /usr/local/etc/waisserver waisserver -s \
  40.         -d /usr/logins/mah/wais-sources
  41.  
  42.    Also, add the next line to /etc/services, and tickle your YP server:
  43.     z3950           210/tcp         # wide area information server (wais)
  44.  
  45.  * $Log: server.c,v $
  46.  * Revision 1.48.1.1  1992/07/11  01:03:51  curtisg
  47.  * Changes for SCO UNIX
  48.  *
  49.  * Revision 1.48  92/05/10  14:47:39  jonathan
  50.  * Update for release.
  51.  * 
  52.  * Revision 1.47  92/05/06  17:34:01  jonathan
  53.  * Changed auto-indexing of .src files to use filename_finish_header_function.
  54.  * 
  55.  * Revision 1.46  92/05/04  17:18:32  jonathan
  56.  * Fixed use of merge_pathname in creating INFO database.
  57.  * 
  58.  * Revision 1.45  92/04/28  15:19:18  jonathan
  59.  * Added decoding of IP address to DNS name in init message handler.
  60.  * 
  61.  * Revision 1.44  92/03/26  18:26:41  jonathan
  62.  * Added extra arguments to index_text_file call.
  63.  * 
  64.  * Revision 1.43  92/03/07  19:41:47  jonathan
  65.  * Added IBM defines, courtesy mycroft@hal.gnu.ai.mit.edu,
  66.  * 
  67.  * Revision 1.42  92/03/05  07:07:58  shen
  68.  * add two more dummy arguments to call to init_search_engine
  69.  * 
  70.  * Revision 1.41  92/02/27  09:58:50  jonathan
  71.  * Put back in setting of core limit to max value, when SET_LIMIT is defined.
  72.  * 
  73.  * Revision 1.40  92/02/24  10:07:41  jonathan
  74.  * Removed reporting functions.
  75.  * 
  76.  * Revision 1.39  92/02/21  12:27:15  jonathan
  77.  * Changed logging of segmentation violation and bus errors to mark log with
  78.  * an error code, and close code.
  79.  * 
  80.  * Revision 1.38  92/02/21  11:00:45  jonathan
  81.  * Added wais_log_level
  82.  * 
  83.  * Revision 1.37  92/02/19  10:16:25  jonathan
  84.  * Added build_catalog to auto-indexer.
  85.  * 
  86.  * Revision 1.36  92/02/16  12:33:21  jonathan
  87.  * Removed code refering to NOINETNTOA, since we should use inet_ntoa.
  88.  * 
  89.  * Revision 1.35  92/02/16  12:05:18  jonathan
  90.  * Added code for GCC incompatibility in inet_ntoa (passing structure as
  91.  * pointer).
  92.  * 
  93.  * Revision 1.34  92/02/14  09:07:34  jonathan
  94.  * Set MAXNAPTIME to 0 so it won't sleep.  Changed the WLOG_ERROR to
  95.  * WLOG_WARNING in the log entry.
  96.  * 
  97.  * Revision 1.33  92/02/12  13:44:20  jonathan
  98.  * Added "$Log" so RCS will put the log message in the header
  99.  * 
  100.  * 
  101.  */
  102.  
  103. #define SERVER_DATE "Sun May 10 1992"
  104.  
  105. #ifndef lint
  106. static char *RCSid = "$Header: /y/src/wais/wais-8-b5/ir/RCS/server.c,v 1.48.1.1 1992/07/11 01:03:51 curtisg Exp curtisg $";
  107. #endif
  108.  
  109. #define INFO_DICT    "INFO.dct"
  110. #define LOCKFILE    "/tmp/INFO.lock" /* while re-indexing INFO */
  111. #define NAPTIME     1             /* seconds */
  112. #define MAXNAPTIME  0        /* Don't wait, just go on. */
  113.  
  114. #include "server.h"
  115. #include "sockets.h"
  116. #include <sys/types.h>
  117. #include <sys/stat.h>
  118. #ifdef ultrix
  119. #include <sys/file.h>
  120. #else
  121. #if defined(_IBMR2) || defined(M_UNIX)
  122. #include <fcntl.h>
  123. #else /* ! _IBMR2 */
  124. #ifdef USG
  125. #include <sys/fcntl.h>
  126. #else
  127. #include <sys/file.h>
  128. #endif
  129. #endif /* _IBMR2 */
  130. #endif /* else ultrix */
  131. #ifdef SYSV            
  132. #define SIGCHLD SIGCLD
  133. #endif
  134. #include <signal.h>
  135. #include <string.h>
  136. #include "irdirent.h"
  137. #include "panic.h"
  138. #include "ustubs.h"
  139. #include "transprt.h"
  140. #include "wmessage.h"
  141. #include "ir.h"
  142. #include "wprot.h"
  143. #include "cutil.h"
  144. #include "futil.h"
  145. #include "irext.h"
  146. #include "irsearch.h"
  147.  
  148. /* to create the INFO index */
  149. #include "irtfiles.h"
  150. #include "irfiles.h"
  151. #include "irhash.h"
  152. #include "version.h"
  153.  
  154. static long bufferSize = BUFSZ; /* how much we are using
  155.                                    (we get one of these per process) */
  156.  
  157. char *log_file_name = NULL;
  158.  
  159. FILE *logfile; /* the logfile */
  160.  
  161. /*---------------------------------------------------------------------------*/
  162.  
  163. #define TIMEOUT_LENGTH 36000 /* ten hour timeout. */
  164. #define IDLE_TIME "10 hours"
  165.  
  166. void
  167. serve_client(in,out, index_directory)
  168. FILE* in;
  169. FILE* out;
  170. char *index_directory;
  171. { 
  172.   char buf[BUFSZ];        /* contains the message and header */
  173.   char *bufPtr ;        /* points at the begining of the z3950 */
  174.   long size;            /* bytes in the z3950 message */
  175.   WAISMessage header;        /* for storing the header */
  176.   long i;
  177.   long bytesLeft;
  178.   struct itimerval new, old;
  179.   long nextChar;
  180.  
  181.   new.it_interval.tv_sec = 0;
  182.   new.it_interval.tv_usec = 0;
  183.   new.it_value.tv_sec = TIMEOUT_LENGTH;
  184.   new.it_value.tv_usec = 0;
  185.  
  186.   getitimer(ITIMER_REAL, &old);
  187.   while (TRUE)
  188.     {
  189.       /* try to read the header */
  190.       for (i = 0; i < HEADER_LENGTH; i++)
  191.     { 
  192.       setitimer(ITIMER_REAL, &new, NULL);
  193.       nextChar = fgetc(in);
  194.       if (nextChar == EOF)    /* my connection exited, so will I */
  195.         { 
  196.           return;
  197.         }
  198.       else
  199.         buf[i] = (char)nextChar;
  200.     }
  201.  
  202.       setitimer(ITIMER_REAL, &old, NULL);
  203.       /* parse the header */
  204.       readWAISPacketHeader(buf,&header);
  205.  
  206.       /* make sure we have the right version.  
  207.      If we dont, we dont know what to do. */
  208.       if (header.hdr_vers > HEADER_VERSION)
  209.     panic("Incompatable header versions (Current version: %c, supplied version: %c.", 
  210.           HEADER_VERSION, header.hdr_vers) ;
  211.  
  212.       /* determine the size of the z3950 message */
  213.       {
  214.     char length_array[11];
  215.     strncpy(length_array, header.msg_len, 10);
  216.     length_array[10] = '\0';
  217.     size = atol(length_array);
  218.       }
  219.  
  220.       /* set bufPtr to start the z3950 message */
  221.       bufPtr = buf + HEADER_LENGTH ;
  222.  
  223.       /* read the z3950 message */
  224.       for (i = 0; i < size ; i++) {
  225.     setitimer(ITIMER_REAL, &new, NULL);
  226.     buf[i + HEADER_LENGTH] = (char)fgetc(in) ;
  227.       }
  228.  
  229.       rewind(in);
  230.  
  231.       /* decode the z3950 if necessary */
  232.       transportDecode((long)header.encoding,bufPtr,&size);
  233.      
  234.       /* XXX handle compression options */
  235.  
  236.       /* process it the z3950 */
  237.       bytesLeft = bufferSize;
  238.  
  239.       size = interpret_buffer(bufPtr,size,bufPtr,bytesLeft,
  240.                   &bufferSize,(long)header.hdr_vers,
  241.                   index_directory); 
  242.  
  243.       /* re-encode the message if necessary */
  244.       transportCode((long)header.encoding,bufPtr,&size); 
  245.  
  246.       /* XXX handle compression options */
  247.  
  248.       /* write the new header */
  249.       writeWAISPacketHeader(buf,size,
  250.                 (long)header.msg_type,header.server,
  251.                 (long)header.compression,(long)header.encoding,
  252.                 (long)header.hdr_vers);
  253.  
  254.       /* write the whole response to the output file */
  255.       for (i = 0; i < size + HEADER_LENGTH; i++)
  256.     fputc(buf[i],out) ;
  257.  
  258.       fflush(out);        /* flush any file buffers */
  259.       rewind(out);        /* reset the file for read */
  260.  
  261.     }
  262. }
  263.  
  264. /*---------------------------------------------------------------------------*/
  265.  
  266. #ifndef ISC
  267. static void breakKey _AP((long s1,long s2,struct sigcontext* s3,char* s4));
  268. #endif
  269.  
  270. static void
  271. breakKey (s1,s2,s3,s4)
  272. long s1;
  273. long s2;
  274. struct sigcontext *s3;
  275. char *s4;
  276. {
  277.   if(0 != finished_search_engine())
  278.     panic("unable to close search engine");
  279.   panic ("got a ^c");
  280. }
  281.  
  282. /*---------------------------------------------------------------------------*/
  283.  
  284. void
  285. childhandler(sig, code, scp, addr)
  286. long sig, code;
  287. struct sigcontext *scp;
  288. char *addr;
  289. {
  290.   wait(NULL);            /* give the kid a decent burial */
  291. }
  292.  
  293. /*---------------------------------------------------------------------------*/
  294.  
  295. void
  296. alarmhandler(sig, code, scp, addr)
  297. long sig, code;
  298. struct sigcontext *scp;
  299. char *addr;
  300. {
  301.   waislog(WLOG_HIGH, WLOG_CLOSE,
  302.       "Server idle longer %s. Closing server and exiting.", IDLE_TIME);
  303.   if(0 != finished_search_engine())
  304.     panic("unable to close search engine");
  305.   exit(0);
  306. }
  307.  
  308. /*---------------------------------------------------------------------------*/
  309.  
  310. void
  311. seghandler(sig, code, scp, addr)
  312. long sig, code;
  313. struct sigcontext *scp;
  314. char *addr;
  315. {
  316.   waislog(WLOG_HIGH, WLOG_ERROR, "Segmentation violation.");
  317.   waislog(WLOG_HIGH, WLOG_CLOSE, "Bummer. Closing server and exiting.");
  318.   abort();
  319. }
  320.  
  321. /*---------------------------------------------------------------------------*/
  322.  
  323. void
  324. bushandler(sig, code, scp, addr)
  325. long sig, code;
  326. struct sigcontext *scp;
  327. char *addr;
  328. {
  329.   waislog(WLOG_HIGH, WLOG_ERROR, "Bus error.");
  330.   waislog(WLOG_HIGH, WLOG_CLOSE, "Bummer. Closing server and exiting.");
  331.   abort();
  332. }
  333.  
  334. /*---------------------------------------------------------------------------*/
  335.  
  336. #include <pwd.h>
  337.  
  338. int finduid(name)
  339. char *name;
  340. {
  341.   struct passwd *pwent;
  342.  
  343.   if ((pwent = getpwnam(name)) == NULL) {
  344.     return -1;
  345.   }
  346.  
  347.   return(pwent->pw_uid);
  348. }
  349.  
  350. static  char *index_dir = NULL;
  351. static  time_t info_change_time;
  352. static  int indexing_needed = 0;
  353. static  char *info_dict = INFO_DICT;
  354.  
  355. extern int alphasort();
  356.  
  357. /* selecttion function for scandir()
  358.  * trigger on ".src" extension, regular file, and != "INFO.src"
  359.  * Indexing is needed if any of the .src files is younger than 
  360.  * INFO.dct
  361.  */
  362. static int
  363. srcfiles(e)
  364.     struct dirent *e;
  365. {
  366.     struct stat sb;
  367.     char *lastdot = strrchr(e->d_name,'.');
  368.     int candidate;
  369.  
  370.     candidate =    lastdot && 
  371.           (stat(merge_pathnames(e->d_name,index_dir), &sb) >= 0) && 
  372.           ((sb.st_mode & S_IFMT) == S_IFREG) &&
  373.           !strcmp(lastdot,source_ext) && 
  374.           strcmp(e->d_name,info_dict); /* whew */
  375.  
  376.         if (candidate) {
  377.         indexing_needed |= (sb.st_mtime > info_change_time);
  378.         return 1;
  379.     }
  380.     return 0;
  381. }
  382.  
  383.  
  384. /*---------------------------------------------------------------------------*/
  385.  
  386. #ifdef SET_LIMIT
  387. #include <sys/resource.h>
  388. #endif
  389.  
  390. #define INDEX_FORK
  391.  
  392. extern char *inet_ntoa ();
  393.  
  394. void
  395. main(argc,argv)
  396. int argc;
  397. char* argv[];
  398. { FILE *file;
  399.   long socket;
  400.   char *next_argument = next_arg(&argc, &argv), *command_name;
  401.   boolean use_stdio = TRUE;        /* default is true */
  402.   /* char *log_file_name = NULL; */    /* name of file for error output */
  403.   int child_proc;        /* for the child process id */
  404.   char *uid_name = "root";    /* user id so setuid if root */
  405.   int uid = 0;        /* if not specified, leave as root. */
  406.   int child;
  407.   long cm_mem_percent = 0;  /* default */
  408.   struct stat statbuf;
  409.   struct dirent **list;
  410.   int naptime = 0;
  411.   extern int errno;
  412.   extern char *sys_errlist[];
  413.   char host_name[255], host_address[255];
  414.   extern void filename_finish_header_function();
  415.  
  416. #ifdef SET_LIMIT
  417.   struct rlimit rlp;
  418.  
  419.   getrlimit(RLIMIT_CORE, &rlp);
  420.   rlp.rlim_cur = rlp.rlim_max;
  421.   setrlimit(RLIMIT_CORE, &rlp);
  422. #endif
  423.  
  424.   tcp_port = 210;            /* tcp_port to use */
  425.   command_name = next_argument;
  426.   host_name[0] = 0;
  427.   host_address[0] = 0;
  428.  
  429.   server_name = s_malloc(255);
  430.   gethostname(server_name, 255);
  431.  
  432.   wais_pid = getpid();
  433.  
  434.   if (!strcmp(command_name, "waisserver.d")) {
  435.     struct sockaddr_in source;
  436.     int sourcelen;
  437.  
  438.     sourcelen = sizeof(struct sockaddr_in);
  439.  
  440.     if (!getpeername(fileno(stdout),&source,&sourcelen)) {
  441.       struct hostent *peer = NULL;
  442.  
  443.       peer = gethostbyaddr(&source.sin_addr, 4, AF_INET);
  444.  
  445.       if(peer != NULL)
  446.     sprintf(host_name, "%s", peer->h_name);
  447.  
  448.       sprintf(host_address, "%s",
  449. #if defined(sparc) && defined(__GNUC__)
  450.           inet_ntoa(&source.sin_addr)
  451. #else
  452.           inet_ntoa(source.sin_addr)
  453. #endif /* sparc */
  454.           );
  455.     }
  456.     else sprintf(host_address, "Error getting socket: %d, %s.", errno, sys_errlist[errno]);
  457.  
  458.     use_stdio = TRUE;
  459.   }
  460.  
  461.   if (argc == 0){
  462.     fprintf(stderr,"Usage: %s [-p [port_number]] [-s] [-d directory] [-u user] [-cmmem number] [-v]\n",
  463.        command_name);
  464.     fprintf(stderr," -p [port] listen to the port.  If the port is supplied, then\n");
  465.     fprintf(stderr,"    that tcp_port number is used.  If it is not supplied \n");
  466.     fprintf(stderr,"    then the Z39.50 port (210) is used.\n");
  467.     fprintf(stderr," -d directory: means to use the directory as the source of databases.\n");
  468.     fprintf(stderr,"    Defaults to the current directory.\n");
  469.     fprintf(stderr," -e [file]: set log output to file, or /dev/null if not specified.\n");
  470.     fprintf(stderr," -l log_level: set log level.  0 means log nothing,\n");
  471.     fprintf(stderr,"    10 [the default] means log everything.\n");
  472.     fprintf(stderr," -s means listen to standard I/O for queries.  This is the default\n");
  473.     fprintf(stderr," -u user: if started as root, setuid to user after startup.\n");
  474.     fprintf(stderr," -cmmem number: percentage of CM memory to use (CM code only).\n");
  475.     fprintf(stderr," -v prints the version.\n");
  476.     exit(1);
  477.   }
  478.   if(NULL == (next_argument = next_arg(&argc, &argv))){
  479.     fprintf(stderr,"No arguments specified\n");
  480.     exit(0);
  481.   }
  482.   while((next_argument != NULL) &&
  483.     ('-' == next_argument[0])){
  484.  
  485.     /* then we have an argument to process */
  486.     if (0 == strcmp("-p", next_argument)){
  487.       char *peek_argument = peek_arg(&argc, &argv);
  488.       use_stdio = FALSE;
  489.       if ((NULL != peek_argument) && /* if we are not out of args */
  490.       ('-' != peek_argument[0])){ { /* and the next isn't an option... */
  491.         /* get the port number */
  492.         tcp_port = atoi(next_arg(&argc, &argv));
  493.       }            /* end if (explicit tcp_port) */
  494.                     }
  495.     }                /* end if (-p) */
  496.     else if (0 == strcmp("-s", next_argument)){
  497.       use_stdio = TRUE;
  498.     }                /* end if (-s) */
  499.  
  500.     else if (0 == strcmp("-e", next_argument)) {
  501.       char *peek_argument = peek_arg(&argc, &argv);
  502.       log_file_name = "/dev/null"; /* default to /dev/null */
  503.       if ((peek_argument != NULL) &&
  504.       ('-' != peek_argument[0])) {
  505.     log_file_name = next_arg(&argc, &argv);
  506.       }                /* end if (explicit log file) */
  507.     }                /* end if (-e) */
  508.     else if (0 == strcmp("-l", next_argument)) {
  509.       wais_log_level = atol(next_arg(&argc, &argv));
  510.     }                /* end if (-l) */
  511.     else if (0 == strcmp("-d", next_argument)) {
  512.       index_dir = next_arg(&argc, &argv);
  513.     }
  514.     else if (0 == strcmp("-v", next_argument)) {
  515.       fprintf(stderr,"%s: %s, %s\n", command_name, VERSION, SERVER_DATE);
  516.     }
  517.     else if (0 == strcmp("-u", next_argument)) {
  518.       uid_name = next_arg(&argc, &argv);
  519.       if((uid = finduid(uid_name)) < 0)
  520.     panic("Couldn't find user %s.", uid_name);
  521.     }
  522.     else if(0 == strcmp("-cmmem", next_argument)){
  523.       if(NULL == (next_argument = next_arg(&argc, &argv)))
  524.     panic("Expected a number (1-100) for percentage of memory to use");
  525.       cm_mem_percent = atol(next_argument);
  526.       if(cm_mem_percent < 1)
  527.     panic("The -cmmem argument should not be less than 1 and less than 100");
  528.       if(cm_mem_percent > 100)
  529.     panic("Warning: The -cmmem parameter was %ld%%. It should be between 1-100.", cm_mem_percent);
  530.     }
  531.     else{
  532.       panic("Don't recognize the %s option", next_argument);
  533.     }
  534.     next_argument = next_arg(&argc, &argv);
  535.   }                /* end while (more arguments) */
  536.  
  537.   if (use_stdio && log_file_name == NULL) 
  538.     log_file_name = "/dev/null";
  539.  
  540.   if (log_file_name == NULL) 
  541.     logfile = stderr;
  542.   else logfile = NULL;
  543.   
  544.   index_dir = index_dir ? index_dir : ".";  
  545.   info_dict = s_strdup(merge_pathnames(info_dict,index_dir));
  546.  
  547.   if(0 != init_search_engine(index_dir, false, true, cm_mem_percent,0,0))
  548.     panic("unable to initialize search engine");
  549.   
  550.   /* remember timestamp on INFO.dct if rebuilding needed 
  551.    * If it doesnt exist, it's assumed to be *very* old, to force
  552.    * re-indexing
  553.    */
  554.   info_change_time = (stat(info_dict,&statbuf) == -1) ? 0 : statbuf.st_mtime;
  555.   
  556.   /* compare with candidates */
  557.  
  558.   if (scandir(index_dir, &list, srcfiles, alphasort) < 0) {
  559.       waislog(WLOG_HIGH, WLOG_ERROR, 
  560.           "Error: reading directory %s, %s", 
  561.           index_dir, sys_errlist[errno]);
  562.       indexing_needed = FALSE;
  563.   }
  564.   
  565.   /* ok. we know if we need indexing, 
  566.    * and have all the filenames. 
  567.    */
  568.   
  569.   if (info_change_time == 0) indexing_needed = TRUE;
  570.   if (indexing_needed) {
  571.  
  572.     /* Time to re-index,
  573.      * aquire the lock 
  574.      */
  575.     waislog(WLOG_MEDIUM, WLOG_INDEX,
  576.         "re-indexing needed, info_change_time=%d",info_change_time); 
  577.  
  578.     if (open(LOCKFILE, O_WRONLY|O_CREAT|O_EXCL,0666) == -1) {
  579.       
  580.       /* already locked by somebody else
  581.        * spin  till she finishes
  582.        */
  583.       while (!(stat(LOCKFILE,&statbuf) == -1)) {
  584.     sleep(NAPTIME);
  585.     naptime += NAPTIME;
  586.     waislog(WLOG_MEDIUM, WLOG_INFO,
  587.         "INFO locked, waiting since %d seconds", naptime);
  588.     if (naptime  > MAXNAPTIME)  {
  589.  
  590.       waislog(WLOG_HIGH, WLOG_WARNING,
  591.           "Warning - lockfile %s won't go away after %d seconds, not reindexing.", 
  592.           LOCKFILE, naptime);
  593.       break;
  594.     }
  595.       }
  596.       /* if lockfile went away, assume INFO.* build finished
  597.        * so just use it
  598.        */
  599.     } else {            /* we aquired the lock, so rebuild database  */
  600.       
  601. #ifdef INDEX_FORK
  602.       if (!(child = fork())) {
  603. #endif
  604.     database *db;
  605.     struct dirent **s = list;
  606.     char filename[MAX_FILENAME_LEN], *dbname;
  607.  
  608.     waislog(WLOG_MEDIUM, WLOG_INDEX,
  609.         "Creating INFO database, pid=%d",getpid());
  610.     dbname = s_strdup(merge_pathnames("INFO",    index_dir));
  611.     db = openDatabase(dbname, true, /* maybe this should append XXX */
  612.               false);
  613.     s_free(dbname);
  614.     init_add_word(db, 0, 100000L);
  615.  
  616.     while (*s) {        /* index it */
  617.       strncpy(filename, index_dir, MAX_FILENAME_LEN);
  618.       if(index_dir[strlen(index_dir) -1] != '/')
  619.         strncat(filename, "/", MAX_FILENAME_LEN);
  620.       strncat(filename, (*s)->d_name, MAX_FILENAME_LEN);
  621.       waislog(WLOG_MEDIUM, WLOG_INDEX,
  622.           "Indexing %s", filename);
  623.       index_text_file(filename, NULL, NULL, NULL, 
  624.               filename_finish_header_function,
  625.               "WSRC", db, true, false,
  626.               false, true);
  627.       s++;
  628.     }
  629.     freedir(list);        /* array of filenames */
  630.           
  631.     if(!probe_file(source_filename(filename, db)))
  632.       write_src_structure(source_filename(filename, db),
  633.                   "INFO", "WSRC", NULL, 0L, true, tcp_port);
  634.     finished_add_word(db);
  635.     build_catalog(db);
  636.     closeDatabase(db);
  637.     if (unlink(LOCKFILE))
  638.       panic("Indexer: cant unlink lockfile!\n");
  639.     waislog(WLOG_MEDIUM, WLOG_INDEX,
  640.         "Indexer pid=%d done", getpid());
  641.           
  642. #ifdef INDEX_FORK
  643.     exit(0);        /* indexing child */
  644.       }
  645.       else if (child == -1) {
  646.     waislog(WLOG_HIGH, WLOG_ERROR,
  647.         "Unable to fork for indexer.");
  648.     exit(1);
  649.       }
  650.       /* wait for child process */
  651.       else while (wait(0) != child) ; /* do nothing */
  652. #endif      
  653.     }
  654.   }
  655.  
  656.  
  657.   if (use_stdio == TRUE) {
  658.     if(host_address[0] != 0){
  659.       waislog(WLOG_MEDIUM, WLOG_CONNECT,
  660.           "Accepted connection from: %s [%s], %s",
  661.           host_name, host_address, VERSION);
  662.     }
  663.     else{
  664.       waislog(WLOG_MEDIUM, WLOG_CONNECT,
  665.           "Couldn't determine peer connection. %s", VERSION);
  666.     }
  667.   }
  668.   else{
  669.     waislog(WLOG_MEDIUM, WLOG_INFO, "Running server %s", VERSION);
  670.   }
  671.  
  672.   signal(SIGINT, breakKey);
  673.  
  674.   signal(SIGCHLD, childhandler);      /* XXX dont really need this any more */
  675.   signal(SIGALRM, alarmhandler);
  676.  
  677.   signal(SIGSEGV, seghandler);
  678.  
  679.   signal(SIGBUS, bushandler);
  680.  
  681.   if(use_stdio == FALSE)
  682.    { 
  683.      if (tcp_port < 1024 && getuid() != 0) {
  684.        waislog(WLOG_HIGH, WLOG_ERROR,
  685.            "Error opening port %d:  Must be superuser to use a port < 1024",
  686.            tcp_port);
  687.        exit(-1);
  688.      }
  689.  
  690.      open_server(tcp_port,&socket,BUFSZ);
  691.  
  692. #ifdef SECURE_SERVER
  693.      /* if root, setuid to user specified id. */
  694.      if (uid > 0 && getuid() == 0)  {
  695.        waislog(WLOG_MEDIUM, WLOG_INFO,
  696.            "Setting uid to %s.", uid_name);
  697.        if (chown(log_file_name,uid,getgid()) < 0)
  698.      waislog(WLOG_HIGH, WLOG_ERROR,
  699.          "Unable to chown log file to %s!", uid_name);
  700.        if ( 0 > setuid(uid)) {
  701.      waislog(WLOG_HIGH, WLOG_ERROR,
  702.          "Unable to setuid to %s!  Exiting.", uid_name);
  703.      exit(-1);
  704.        }
  705.      }
  706. #endif
  707.      while (TRUE) { /* be a server for several connections */
  708.        accept_client_connection(socket,&file);
  709.       
  710.        if ((child_proc = fork()) == 0) {
  711.           
  712.           /* grandson handles this connection
  713.            * double-fork takes care of zombies 
  714.            */
  715.           if ((child_proc = fork()) == 0) { 
  716.         wais_pid = getpid();
  717.         log_line = 0;
  718.         serve_client(file, file, index_dir);
  719.         /* but leaves server up */
  720.         close_client_connection(file);
  721.         close_server(socket);
  722.         /* just exits this child */
  723.         waislog(WLOG_MEDIUM, WLOG_CLOSE,
  724.             "Done handling client");
  725.         exit(0);
  726.           } else {
  727.         /* son: orphans the grandchild, so init picks up 
  728.          * the exit status
  729.          */
  730.         exit(0);
  731.           }
  732.           } else {
  733.           waislog(WLOG_MEDIUM, WLOG_INFO,
  734.               "Child PID = %d", child_proc);
  735.           close_client_connection(file);     /* parent shouldn't keep the file */
  736.       }
  737.       }
  738.    }
  739.   else if(use_stdio == TRUE)
  740.    { /* connections on stdio don't use child processes yet */
  741.      serve_client(stdin, stdout, index_dir);
  742.      waislog(WLOG_MEDIUM, WLOG_CLOSE,
  743.          "Done handling client");
  744.       /* close the whole thing */
  745.      if(0 != finished_search_engine())
  746.        panic("unable to close search engine");
  747.      exit(0);
  748.    }
  749. }
  750.  
  751. /*---------------------------------------------------------------------------*/
  752.  
  753.